const { apiKey, systemContent, maxTokens } = require('@/config/default').aliyun;

const validate = require('@/validate/index')
const tools = require('@/config/tools')
const OpenAI = require('openai')
const config = require('@/config/default')

// 动态导入12306-mcp模块
let mcpServer = null;
const initMcpServer = async () => {
    if (!mcpServer) {
        try {
            const mcpModule = await import('../12306-mcp/build/index.js');
            mcpServer = mcpModule.server;
        } catch (error) {
            console.error('Failed to initialize 12306-mcp server:', error);
        }
    }
    return mcpServer;
}

const openai = new OpenAI(
    {
        apiKey: apiKey,
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
    }
);

class ChatController {
    // 对话，流式输出
    async chatMessage(ctx) {
        // 提前保存this上下文
        const self = this;

        const { chatMessage } = ctx.request.body;
        // 校验参数
        await validate.arrayCheck(chatMessage, 'chatMessage字段不能为空', 'chatMessage');

        // 发送请求到OpenAI模型
        const completion = await openai.chat.completions.create({
            model: "qwen-plus",// 模型名称
            messages: [
                { role: "system", content: systemContent },
                ...chatMessage,
            ],
            stream: true,
            tools: tools,
            max_tokens: maxTokens, // 限制AI输出的最大token数量
        });

        // 设置响应头，支持流式传输
        ctx.set({
            'Content-Type': 'text/event-stream',
            'Cache-Control': 'no-cache',
            'Connection': 'keep-alive',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Headers': 'Content-Type',
            'Access-Control-Allow-Methods': 'POST, OPTIONS'
        });

        // 发送初始连接确认
        ctx.res.write(`data: ${JSON.stringify({ type: 'connected' })}

`);

        // 处理流式输出
        let toolCallInfo = null;
        let collectedToolArguments = null;
        let isHandlingToolCall = false;

        try {
            for await (const chunk of completion) {
                console.log(JSON.stringify(chunk));

                // 检查是否有文本内容
                if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.content) {
                    // 立即将文本片段发送给前端
                    const textChunk = chunk.choices[0].delta.content;
                    ctx.res.write(`data: ${JSON.stringify({ 
                        type: 'text', 
                        content: textChunk 
                    })}\n\n`);
                }

                // 检查是否有工具调用请求
                if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta && chunk.choices[0].delta.tool_calls) {
                    const toolCall = chunk.choices[0].delta.tool_calls[0];

                    if (toolCall.function) {
                        // 记录工具名称（如果有）
                        if (toolCall.function.name) {
                            toolCallInfo = toolCall.function.name;
                        }

                        // 正确拼接增量参数
                        if (toolCall.function.arguments) {
                            if (!collectedToolArguments) {
                                collectedToolArguments = '';
                            }
                            collectedToolArguments += toolCall.function.arguments;
                            isHandlingToolCall = true;
                        }
                    }
                }

                // 检查是否有finish_reason，表明工具调用参数已完整或响应结束
                if (chunk.choices && chunk.choices[0] && chunk.choices[0].finish_reason) {
                    if (chunk.choices[0].finish_reason === 'tool_calls' && isHandlingToolCall) {
                        // 处理火车票查询工具调用
                        try {
                            const toolResult = await self.handleTrainTicketToolCall(collectedToolArguments);
                            // 发送工具调用结果
                            ctx.res.write(`data: ${JSON.stringify({ 
                                type: 'tool_result', 
                                tool: 'queryTrainTickets',
                                success: toolResult.success,
                                data: toolResult.data,
                                message: toolResult.message
                            })}\n\n`);
                        } catch (error) {
                            console.error('工具调用处理失败:', error);
                            ctx.res.write(`data: ${JSON.stringify({ 
                                type: 'tool_result', 
                                tool: 'queryTrainTickets',
                                success: false,
                                message: '火车票查询失败'
                            })}\n\n`);
                        }
                        
                        // 发送结束标志
                        ctx.res.write(`data: ${JSON.stringify({ type: 'end' })}\n\n`);
                        ctx.res.end();
                        return;
                    } else if (chunk.choices[0].finish_reason === 'stop') {
                        // 响应结束，发送结束标志
                        ctx.res.write(`data: ${JSON.stringify({ type: 'end' })}\n\n`);
                        ctx.res.end();
                        return;
                    }
                }
            }
        } catch (error) {
            console.error('流式响应处理错误:', error);
            if (!ctx.res.writableEnded) {
                ctx.res.write(`data: ${JSON.stringify({ 
                    type: 'error', 
                    message: '响应处理出错: ' + (error.message || '未知错误') 
                })}\n\n`);
                ctx.res.end();
            }
        } finally {
            // 确保响应已结束
            if (!ctx.res.writableEnded) {
                ctx.res.write(`data: ${JSON.stringify({ type: 'end' })}\n\n`);
                ctx.res.end();
            }
        }
    }

    // 处理火车票查询工具调用
    async handleTrainTicketToolCall(argumentsStr) {
        try {
            // 解析参数
            let args;
            try {
                args = JSON.parse(argumentsStr);
            } catch (e) {
                // 如果解析失败，尝试提取可能的参数
                args = this.extractTrainTicketParams(argumentsStr);
            }

            const { departure, destination, date } = args;

            // 验证参数
            if (!departure || !destination || !date) {
                return {
                    success: false,
                    message: '请提供完整的出发地、目的地和出行日期'
                };
            }

            // 转换日期格式（如果需要）
            const formattedDate = this.formatDate(date);

            // 调用12306-mcp获取车站编码
            const fromStationCode = await this.getStationCode(departure);
            const toStationCode = await this.getStationCode(destination);

            if (!fromStationCode || !toStationCode) {
                return {
                    success: false,
                    message: '未能获取到车站编码，请检查城市名称是否正确'
                };
            }

            // 调用12306-mcp查询火车票
            const ticketResult = await this.queryTrainTickets(formattedDate, fromStationCode, toStationCode);

            return {
                success: true,
                data: ticketResult
            };
        } catch (error) {
            console.error('处理火车票查询失败:', error);
            return {
                success: false,
                message: '查询火车票失败，请稍后再试'
            };
        }
    }

    // 从字符串中提取火车票查询参数
    extractTrainTicketParams(argumentsStr) {
        const params = {};

        try {
            // 尝试更灵活的方式解析参数
            // 1. 处理可能的JSON片段
            let cleanStr = argumentsStr.trim();

            // 如果字符串以{开头但不以}结尾，尝试补全
            if (cleanStr.startsWith('{') && !cleanStr.endsWith('}')) {
                // 尝试查找最后一个逗号之前的位置
                const lastCommaIndex = cleanStr.lastIndexOf(',');
                if (lastCommaIndex > 0) {
                    cleanStr = cleanStr.substring(0, lastCommaIndex) + '}';
                } else {
                    cleanStr += '}';
                }
            }

            // 尝试使用简化的正则表达式提取参数
            // 提取出发地
            const departureMatch = cleanStr.match(/"departure"\s*:\s*"([^"]*)"/);
            if (departureMatch && departureMatch[1]) {
                params.departure = departureMatch[1];
            }

            // 提取目的地
            const destinationMatch = cleanStr.match(/"destination"\s*:\s*"([^"]*)"/);
            if (destinationMatch && destinationMatch[1]) {
                params.destination = destinationMatch[1];
            }

            // 提取日期
            const dateMatch = cleanStr.match(/"date"\s*:\s*"([^"]*)"/);
            if (dateMatch && dateMatch[1]) {
                params.date = dateMatch[1];
            }

        } catch (e) {
            console.error('解析参数失败:', e);
        }

        return params;
    }

    // 格式化日期
    formatDate(dateStr) {
        // 尝试多种日期格式转换
        if (dateStr.match(/\d{4}-\d{2}-\d{2}/)) {
            return dateStr;
        } else if (dateStr.match(/\d{4}年\d{1,2}月\d{1,2}日/)) {
            // 转换 2025年9月22日 格式为 2025-09-22
            return dateStr.replace(/年|月/g, '-').replace(/日/g, '');
        }
        return dateStr;
    }

    // 获取车站编码
    async getStationCode(cityName) {
        try {
            // 确保mcpServer已初始化
            const server = await initMcpServer();
            if (!server) {
                console.error('MCP server is not initialized');
                return null;
            }

            // 调用12306-mcp的get-station-code-of-citys工具
            const result = await server.callTool('get-station-code-of-citys', { citys: cityName });
            const data = JSON.parse(result.content[0].text);

            if (data[cityName] && data[cityName].station_code) {
                return data[cityName].station_code;
            }

            // 如果城市编码获取失败，尝试获取该城市的所有车站并返回第一个
            const cityStationsResult = await server.callTool('get-stations-code-in-city', { city: cityName });
            const cityStationsData = JSON.parse(cityStationsResult.content[0].text);

            if (cityStationsData && cityStationsData.length > 0) {
                return cityStationsData[0].station_code;
            }

            return null;
        } catch (error) {
            console.error('获取车站编码失败:', error);
            return null;
        }
    }

    // 查询火车票
    async queryTrainTickets(date, fromStation, toStation) {
        try {
            // 确保mcpServer已初始化
            const server = await initMcpServer();
            if (!server) {
                throw new Error('MCP server is not initialized');
            }

            // 调用12306-mcp的get-tickets工具
            const result = await server.callTool('get-tickets', {
                date: date,
                fromStation: fromStation,
                toStation: toStation,
                trainFilterFlags: '', // 不筛选车次类型
                earliestStartTime: 0, // 最早出发时间
                latestStartTime: 24, // 最晚出发时间
                sortFlag: 'startTime', // 按出发时间排序
                sortReverse: false, // 正序排列
                limitedNum: 0, // 不限制数量
                csvFormat: false // 不使用CSV格式
            });

            return result.content[0].text;
        } catch (error) {
            console.error('查询火车票失败:', error);
            throw error;
        }
    }
}

module.exports = new ChatController();